# -*- coding: UTF-8 -*-
# -*- coding: UTF-8 -*-
from tkinter import *
import sys
import socket
import types
sys.path.append("../Objets-Ali/François TechTree")
#import techtree
from tkinter import ttk

import winsound


class Vue():
    def __init__(self, controleur):
        self.master = Tk()
        self.controleur = controleur
        self.master.protocol("WM_DELETE_WINDOW", self.controleur.deconnexion) #Retire le joueur de la liste quand il ferme la fenêtre du programme
        
    def afficherLogin(self):
        self.frameLogin = Frame(self.master, width=400, height=400) #Frame de login
        self.frameLogin.pack()
        self.frameCourant = self.frameLogin #FrameCourant est toujours le frame presentement affiche
        self.frameLogin.bind_all("<Return>", lambda e: self.controleur.validerLogin(self.entIP.get(), self.entNom.get(), self.entMdp.get())) #Peu importe ou se trouve le focus, quand on appuie sur enter, ca essaie de se connecter au serveur
        
        self.etiqNom = Label(self.frameLogin, text="Nom d'utilisateur")
        self.etiqNom.pack()
    
        self.entNom = Entry(self.frameLogin)
        self.entNom.insert(0, "Adam")
        self.entNom.pack()
        self.entNom.focus() #Donne le focus au champ pour entrer le nom
        
        self.etiqMdp = Label(self.frameLogin, text="Mot de passe")
        self.etiqMdp.pack()
        
        self.entMdp = Entry(self.frameLogin)
        self.entMdp.insert(0, "Smith")
        self.entMdp.pack()
        
        self.etiqIP = Label(self.frameLogin, text="Adresse IP")
        self.etiqIP.pack()
        
        self.entIP = Entry(self.frameLogin)
        self.entIP.insert(0, self.controleur.getMyIp()) #Ip par defaut est le notre
        self.entIP.pack()
        
        self.bouton = Button(self.frameLogin, text="Connexion", command=lambda: self.controleur.validerLogin(self.entIP.get(), self.entNom.get(), self.entMdp.get()))
        self.bouton.pack()
        
        self.master.mainloop()
    
    def afficherLobby(self):
        self.widthEspaceJeu = self.controleur.getWidthEspaceJeu()
        self.heightEspaceJeu = self.controleur.getHeightEspaceJeu()
        
        self.frameSalle = Frame(self.master, width=self.widthEspaceJeu, height=self.heightEspaceJeu)
        self.changerFrame(self.frameSalle)
        self.frameSalle.pack_propagate(0)
        
        self.frameSalle.bind_all("<Return>", lambda insertionTexte: self.insererTexteChat(self.entreChat.get()))
        
        self.etiqSalle = Label(self.frameSalle, text="Lobby")
        self.etiqSalle.grid(row=0, column=0)
        
        self.listbox = Listbox(self.frameSalle)
        self.listbox.grid(row=1, column=0)
        
        self.etiqNb = Label(self.frameSalle)
        self.etiqNb.grid(row=2, column=0)
        
        self.etiqChat = Label(self.frameSalle, text="Chat")
        self.etiqChat.grid(row=0, column=3)
        
        self.textChat = Text(self.frameSalle, width=100)
        self.textChat.grid(row=1, column=4, columnspan=4)
        
        self.boutonChat = Button(self.frameSalle, text="Envoyer", command=lambda insertionTexte: self.insererTexteChat(self.entreChat.get()))
        self.boutonChat.grid(row=3, column=5, sticky=W)
        
        self.entreChat = Entry(self.frameSalle, width=50)
        self.entreChat.grid(row=3, column=4, sticky=W)
        self.entreChat.focus()
        
        if self.controleur.getJoueurCourant() == self.controleur.getCreateurPartie(): #Bouton pour debuter la partie seulement si on est le createur
            self.boutonDebutPartie = Button(self.frameSalle, text="Debuter la partie", command=self.controleur.envoiDebutPartie)
            self.boutonDebutPartie.grid(row=3, column=6, sticky=W)
        
        self.etiqAIp = Label(self.frameSalle, text="IP du serveur : " + self.controleur.getIpServeur())
        self.etiqAIp.grid(row=3, column=0)
        
        self.musique()        
    
    #Methode qui va construire la listbox de la salle d'attente
    def misesAJoursLobby(self):
        self.listbox.delete(0, END)
        joueurs = self.controleur.creerListeJoueurs()
        joueurDansLaListe = False
        positionListe = 0
        
        #On affiche le nombre de joueur dans la liste
        if len(joueurs) == 1:
            self.etiqNb.config(text=str(len(joueurs)) + " joueur dans le lobby")
        else:
            self.etiqNb.config(text=str(len(joueurs)) + " joueurs dans le lobby")
        self.etiqNb.grid(row=2, column=0)
            
        for joueur in joueurs:
            self.listbox.insert(END, joueur)
            self.listbox.itemconfig(positionListe, {'bg':self.controleur.retournerListeCouleursJoueurs()[joueurs.index(joueur)], 'fg':'white'})
            positionListe += 1
        
        self.rafraichirChat()
        
    def rafraichirChat(self):
        leTexte = ""
        listeChat = self.controleur.creeListeChat()
        self.textChat.delete(1.0, END)
        
        for texte in listeChat:
            leTexte += texte + "\n"
            
        self.textChat.insert(END, leTexte)
        self.textChat.see(END)

    def musique(self):
        pass
        #try:
        #    winsound.PlaySound('saxguy.wav',winsound.SND_FILENAME | winsound.SND_ASYNC | winsound.SND_LOOP )
        #except:
            #print("no sound!")
            
    def insererTexteChat(self, message, isSourceHud=False):
        self.controleur.insererTexteChat(message)
        self.entreChat.delete(0, END)
        
        if isSourceHud:
            self.hud.entreChat.delete(0, END)
            self.canvas.canvas.focus_set()
        
    def changerFrame(self, leFrame):
        self.frameCourant.pack_forget()
        self.frameCourant = leFrame
        leFrame.pack()
        
    def afficherPartie(self):
        width = self.controleur.partie.widthEspaceJeu
        height = self.controleur.partie.heightEspaceJeu
        worldSize = self.controleur.partie.worldSize
        self.vueCourante = self.controleur.partie.vuePlaneteDepart(self.controleur.partie.joueur.nom)
        ### ARRET DE LA MUSIQUE DE SALLE D'ATTENTE
        #try:
            #winsound.PlaySound('saxguy.wav',winsound.SND_FILENAME | winsound.SND_PURGE )
        #except:
            #print("no sound!")
        ### Je savais pas trop ou mettre cela sinon!
        
        self.minimap = Minimap()
        self.frameJeu = Frame(self.master, width=width, height=height, background="black")
        self.changerFrame(self.frameJeu)
        self.frameDiplomatie=FrameDiplomatie(self, self.frameJeu)
        self.frameTechTree=TechTreeWindow(self, self.frameJeu)
        self.frameHaut = FrameHaut(self, self.frameJeu, width=width, height=25)
        #self.menuNavigation = MenuNavigation(self, self.frameJeu, int(height / 10), int(width / 5))
        self.menuNavigation = MenuNavigation(self, self.frameJeu, 300, int(width / 5))
        self.canvas = Interface(self, self.frameJeu, width, height, worldSize)
        self.hud = Hud(self, self.frameJeu, width, height, worldSize)
        
        
        self.frameHaut.redraw()
        self.canvas.redraw()
        self.hud.redraw()
        self.frameDiplomatie.redraw()
    
    def notificationDiplomatie(self):
        self.frameHaut.bouttonDiplomatie.flash()
    
    def setEnableButtonDiplo(self, nomJoueur, texteBouton, newState):
        self.frameDiplomatie.setEnableButton(nomJoueur, texteBouton, newState)
        
    def retourVue(self):
        if self.vueCourante.typeVue() == "Systeme":
            self.hud.enleverFrameConstruction()
            self.vueCourante = self.vueCourante.galaxie
            self.hud.afficherMenuEntite()
        if self.vueCourante.typeVue() == "Planete":
            self.hud.enleverFrameConstruction()
            self.vueCourante = self.vueCourante.systemeParent
            self.hud.afficherMenuEntite()
        #self.canvas.uniteCourante = []
        if self.hud.frameMilieuLequel=="Construction":
            self.hud.arretPlacerConstruction()
            #self.hud.afficherFrameConstruction()
            self.hud.afficherMenuEntite()
        
    
    def dessinerAttaque(self, coord1, coord2):
        self.canvas.dessinAttaque.append([coord1, coord2, 5])
        try:
            winsound.PlaySound('laser.wav',winsound.SND_FILENAME | winsound.SND_ASYNC )
        except:
            print("No sound!")
            
class MenuNavigation(): #TO-DO: Resizer la listBox
    def __init__(self, vue, frame, height, width):
        self.vue = vue
        self.height = height
        self.width = width
        self.vueCourante = self.vue.vueCourante
        self.frame = frame
        self.menuNavigation = Frame(self.frame, height=self.height, width=width, background="black", relief=RIDGE, borderwidth=10)
        self.menuNavigation.pack(side=LEFT,fill=Y)        

        self.scrollbar = Scrollbar(self.menuNavigation)
        self.scrollbar.pack(side=RIGHT, fill=Y)

        self.mylist = Listbox(self.menuNavigation, yscrollcommand=self.scrollbar.set)   
        
        self.mylist.pack(side=LEFT, fill=BOTH)
        self.scrollbar.config(command=self.mylist.yview)  
        
        self.mylist.bind("<ButtonRelease-1>", self.clicListe)
        self.insertionElements()  
    
    def insertionElements(self):
        self.mylist.delete(0, END)
        
        self.mylist.insert(END, "Le système à " + self.vue.controleur.getJoueurCourant())
        for systeme in self.vue.controleur.partie.listeSystemes:
            entiteSystemeCount = 0
            systemeInsere = False
            
            for entiteSysteme in systeme.listeEntites:
                if entiteSysteme.joueur == self.vue.controleur.getJoueurCourant() and entiteSysteme.typeEntite() == "Unite":
                    entiteSystemeCount += 1
            
            if entiteSystemeCount > 0:
                self.mylist.insert(END, systeme.nom + " (" + str(entiteSystemeCount) + " unites)")
                systemeInsere = True
                
            for planete in systeme.listePlanetes:
                entitePlaneteCount = 0
                
                entiteSystemeCount = 0
            
                for entitePlanete in planete.listeEntites:
                    if entitePlanete.joueur == self.vue.controleur.getJoueurCourant() and entitePlanete.typeEntite() == "Unite":
                        entitePlaneteCount += 1
                    
                if entitePlaneteCount > 0:
                    if not systemeInsere:
                        self.mylist.insert(END, systeme.nom + " (" + str(entiteSystemeCount) + " unites)")
                        systemeInsere = True
                                        
                    self.mylist.insert(END, "--- " + planete.nom + " (" + str(entitePlaneteCount) + " unites)")
                    
    def clicListe(self, event):
        indexSelection = int(self.mylist.curselection()[0])
        
        stringSelectionnee = self.mylist.get(indexSelection)
        
        nomPlanete = None
        nomSysteme = None
        
        if stringSelectionnee.split()[0] == "---":
            nomPlanete = stringSelectionnee.split()[1]
            
            while nomSysteme == None:
                indexSelection -= 1
                
                if self.mylist.get(indexSelection).split()[0] != "---":
                    nomSysteme = self.mylist.get(indexSelection).split()[0]
                
        elif stringSelectionnee.split()[0] != "Le":
            nomSysteme = stringSelectionnee.split()[0]
            
        if nomPlanete == None:
            for objet in self.vue.controleur.partie.listeSystemes:
                if objet.nom == nomSysteme:
                    self.vue.vueCourante = objet
        else:
            for objet in self.vue.controleur.partie.listeSystemes:
                if objet.nom == nomSysteme:
                    for objet2 in objet.listePlanetes:
                        if objet2.nom == nomPlanete:
                            self.vue.vueCourante = objet2
            
        
        
class FrameHaut():
    def __init__(self, vue, frame, width=800, height=30):
        self.vue = vue
        self.vueCourante = self.vue.vueCourante
        self.frame = frame
        self.frameHaut = Frame(self.frame, height=height,  background="black", relief=RIDGE, borderwidth=10)
        self.frameHaut.pack(side=TOP, fill=X)
        self.ress = ""
        #self.ressourcesJoueur = Label(self.frameHaut, text=self.ress, fg="black", bg="gray",relief=RIDGE,borderwidth=3)
        #self.ressourcesJoueur.pack(side=LEFT, fill=X)
        self.bouttonDiplomatie = Button(self.frameHaut, text="Diplomatie", bg="blue", fg="white",font=("Helvetica", 12), command=self.vue.frameDiplomatie.afficher) #command=blabla
        self.bouttonDiplomatie.pack(side=RIGHT)
        self.bouttonTech = Button(self.frameHaut, text="Tech-Tree", bg="blue", fg="white",font=("Helvetica", 12), command=self.vue.frameTechTree.afficher) #command=blabla
        self.bouttonTech.pack(side=RIGHT)
        self.ressourcesJoueur=[]
        self.partieEstCommencer=0
        
        #self.backgroundFrameHaut = PhotoImage(file="images/frameHaut.gif")
        #self.ressourcesJoueur.configure(image=self.backgroundFrameHaut)

    def redraw(self):
        self.vueCourante = self.vue.vueCourante


        
                
        #rafraichissement des ressources du joueur sur une planete        
        if self.vueCourante.typeVue() == "Planete" or self.vueCourante.typeVue() == "Systeme":
            #Si c'est la première fois, création des labels...
            if self.partieEstCommencer == 0:
                self.partieEstCommencer =1
                couleurRessource=""
                for indexRessource in range(len(self.vueCourante.typeRessources)):
                    self.ress = self.vueCourante.typeRessources[indexRessource] + ": " + str(self.vueCourante.ressourcesJoueur[indexRessource])
                    ###couleur du texte = couleur de la ressource
                    if indexRessource == 0:
                        couleurRessource= "grey"
                    elif indexRessource == 1:
                        couleurRessource= "black"
                    elif indexRessource == 2:
                        couleurRessource= "green"
                    elif indexRessource == 3:
                        couleurRessource= "LightPink"
                    elif indexRessource == 4:
                        couleurRessource= "white"
                    elif indexRessource == 5:
                        couleurRessource= "red"
                    elif indexRessource == 6:
                        couleurRessource= "gold"
                    elif indexRessource == 7:
                        couleurRessource= "burlywood4"
                    self.ressourcesJoueur.append(Label(self.frameHaut, text=self.ress, fg=couleurRessource, bg="blue",relief=RIDGE,borderwidth=3,  font=("Helvetica", 13)))
                    self.ressourcesJoueur[indexRessource].pack(side=LEFT, fill=X)

            self.ress = ""
            for indexRessource in range(len(self.vueCourante.typeRessources)):
                self.ressourcesJoueur[indexRessource].pack(side=LEFT, fill=X)
                self.ress = self.vueCourante.typeRessources[indexRessource] + ": " + str(self.vueCourante.ressourcesJoueur[indexRessource])
                self.ressourcesJoueur[indexRessource].config(text=self.ress)

            # VERSION 1 sans couleurs
            #for kathleen in range(len(self.vueCourante.typeRessources)):
            #    self.ress = self.ress + self.vueCourante.typeRessources[kathleen] + ": " + str(self.vueCourante.ressourcesJoueur[kathleen]) + "    "
            #self.ressourcesJoueur.config(text=self.ress)
        #if self.vueCourante.typeVue() == "Galaxie":
            #self.ressourcesJoueur.config(text="")
            
        if self.vueCourante.typeVue() == "Galaxie":
            try:
                for indexRessource in range(len(self.ressourcesJoueur)):
                    self.ressourcesJoueur[indexRessource].forget()
            except:
                print("Pas de ressource dans la galaxie")

class FrameDiplomatie():
    def __init__(self, vue,frame, width=300, height=300):
        self.vue = vue
        self.frame=frame
        self.listeFrameJoueur = []
        self.frameDiplomatie = Frame(self.frame, background="white")
        self.estAfficher=False
        self.premiereFois = False
        
    def afficher(self):
        if self.estAfficher:
            self.estAfficher=False
            self.premiereFois = True
        else:
            self.estAfficher=True
            self.premiereFois = True
            
    def redraw(self): 
        self.vue.controleur.traiterDemandes()
        
        if self.estAfficher:
            if(self.premiereFois):
                self.premiereFois = False
                self.remplirListeGUI()
                self.frameDiplomatie.place(x=1005, y=52, anchor=NE)
                self.frameDiplomatie.lift()
            self.updateStatus()
        else:
            if(self.premiereFois):
                self.premiereFois = False
                self.frameDiplomatie.place_forget()
    def updateStatus(self):
        listeStatus = self.vue.controleur.getListeStatus()
        for i in range(len(self.listeFrameJoueur)):
            #Pour réduire les scintillements dans le menu de diplomatie.
            if(self.listeFrameJoueur[i].cget("text") != listeStatus[i][0]+" "+listeStatus[i][1]):
                self.listeFrameJoueur[i].config(text=listeStatus[i][0]+" "+listeStatus[i][1])
            
            demande = self.vue.controleur.getListeDemandes(listeStatus[i][0])
            self.updateBoutonState(self.listeFrameJoueur[i], listeStatus[i], demande)
                
    def updateBoutonState(self, labelFrame, status, demande):
        #(joueurCible, joueurDemandant, type, statut)
        #Liste des status des demandes : attenteReponse, refuse, accepte
        #Liste des types de demande : alliance, traiteDePaix, paix, resilierTraite
        
        #Liste des status des boutons.  Voici l'ordre :
        """
        0- Déclarer la guerre
        1- Refuser alliance
        2- Demander alliance
        3- Résilier alliance
        4- Accepter alliance
        5- Demander paix
        6- Accepter paix
        7- Refuser paix
        """
        listBoolBouton = [DISABLED]* 8 #Crée une list de 8 disabled
        if demande != None:
            if status[1] != "ennemi":
                listBoolBouton[0] = NORMAL
                if status[1] == "allie":
                    listBoolBouton[3] = NORMAL
            elif demande[2] != "paix":
                listBoolBouton[5] = NORMAL      
            if demande[2] == "alliance":
                if demande[1] == status[0]:
                    listBoolBouton[1] = NORMAL
                    listBoolBouton[4] = NORMAL
            elif status[1] != "allie":
                listBoolBouton[2] = NORMAL
            if demande[2] == "paix" and demande[1] == status[0]:
                listBoolBouton[6] = NORMAL
                listBoolBouton[7] = NORMAL
        else:
            if status[1] != "ennemi":
                listBoolBouton[0] = NORMAL
                if status[1] == "allie":
                    listBoolBouton[3] = NORMAL
            else:
                listBoolBouton[5] = NORMAL
            if status[1] != "allie":
                listBoolBouton[2] = NORMAL
        
        self.setEnableButton(status[0], "Déclarer la guerre", listBoolBouton[0], labelFrame)
        self.setEnableButton(status[0], "Refuser alliance", listBoolBouton[1], labelFrame)
        self.setEnableButton(status[0], "Demander alliance", listBoolBouton[2], labelFrame)
        self.setEnableButton(status[0], "Résilier alliance", listBoolBouton[3], labelFrame)
        self.setEnableButton(status[0], "Accepter alliance", listBoolBouton[4], labelFrame)
        self.setEnableButton(status[0], "Demander paix", listBoolBouton[5], labelFrame)
        self.setEnableButton(status[0], "Accepter paix", listBoolBouton[6], labelFrame)
        self.setEnableButton(status[0], "Refuser paix", listBoolBouton[7], labelFrame)
        
    def viderListeGUI(self):
        for i in self.listeFrameJoueur:
            i.grid_remove()
        self.listeFrameJoueur = []
    
    def remplirListeGUI(self):
        listeStatus = self.vue.controleur.getListeStatus()
        newListeFrameJoueur = []
        for i in listeStatus:
            newListeFrameJoueur.append(self.creerElementListe(i))
        for i in range(len(newListeFrameJoueur)):
            try:
                self.listeFrameJoueur[i].grid_remove()
                self.listeFrameJoueur[i] = newListeFrameJoueur[i]
            except IndexError:
                self.listeFrameJoueur.append(newListeFrameJoueur[i])
            self.listeFrameJoueur[i].grid()
        
    #Créer un LabelFrame contenant les informations d'un joueur et les boutons correspondant
    def creerElementListe(self,elementJoueurStatus):
        couleur = self.vue.controleur.getCouleurJoueur(elementJoueurStatus[0])
        element = LabelFrame(self.frameDiplomatie, height=100, width=100,text=elementJoueurStatus[0]+" "+elementJoueurStatus[1], background=couleur, borderwidth=2, relief="ridge")
        self.initWidgetsElement(element, elementJoueurStatus)
        return element
        
    #Il faudra checker pour les demandes d'alliance...status ?
    def initWidgetsElement(self, parent, nomStatus):
        self.creerBoutonDemande(parent,nomStatus[0],"alliance", NORMAL, 0, 0)
        self.creerBoutonAccepter(parent, nomStatus[0], "alliance", 0, 1)
        self.creerBoutonRefuser(parent, nomStatus[0], "alliance", 1, 0)
        self.creerBoutonChangementStatus(parent, nomStatus[0], "neutre", "Résilier alliance", DISABLED, 1, 1)
        self.creerBoutonDemande(parent,nomStatus[0],"paix", DISABLED, 2, 0)
        self.creerBoutonAccepter(parent, nomStatus[0], "paix", 2, 1)
        self.creerBoutonRefuser(parent, nomStatus[0], "paix",3, 0)
        self.creerBoutonChangementStatus(parent, nomStatus[0], "ennemi", "Déclarer la guerre", NORMAL, 3, 1)
    
    def setEnableButton(self, nomJoueur, texteBouton, newState, labelFrame):
        boutons = labelFrame.grid_slaves()
        for ii in boutons:
            if ii.cget("text") == texteBouton:
                if(ii.cget("state") != newState):
                   ii.config(state=newState)
                return
            
    def creerBoutonDemande(self, parent, nomJoueur, type, state, colonne, rangee):
        demande = [nomJoueur, self.vue.controleur.getJoueurCourant(), type, "attenteReponse"] 
        b = Button(parent, state= state, text="Demander "+type, command=lambda : self.vue.controleur.envoyerDemande(demande))
        b.grid(column=colonne, row=rangee)
    
    def creerBoutonAccepter(self, parent, nomJoueur, type, colonne, rangee):
        demande = [self.vue.controleur.getJoueurCourant(), nomJoueur, type, "accepte"] 
        b = Button(parent, state=DISABLED, text="Accepter "+type, command=lambda : self.vue.controleur.accepterDemande(demande))
        b.grid(column=colonne, row=rangee)
    
    def creerBoutonRefuser(self, parent, nomJoueur, type, colonne, rangee):
        demande = [self.vue.controleur.getJoueurCourant(), nomJoueur, type, "refuse"] 
        b = Button(parent, state=DISABLED, text="Refuser "+type, command=lambda : self.vue.controleur.refuserDemande(demande))
        b.grid(column=colonne, row=rangee)
    
    
    def creerBoutonChangementStatus(self,parent, nomJoueur, newStatus, texteBouton, state, colonne, rangee):
        b = Button(parent, state=state, text=texteBouton, command=lambda : self.vue.controleur.modifierStatus(self.vue.controleur.getJoueurCourant(), nomJoueur, newStatus))
        b.grid(column=colonne, row=rangee)
        
     #(joueurCible,joueurDemandant, type, status)
     
     
class Minimap(): #Sert ÃƒÂ  representer le carrÃƒÂ© brun de l'espace visible dans la minimap
    def __init__(self, posX=0, posY=0, tag="minimap"):
        self.posX = posX
        self.posY = posY

class Interface(): #L'ecran du jeu en tant que tel
    def __init__(self, vue, frame, width, height, worldSize):
        self.vue = vue
        self.vueCourante = self.vue.vueCourante
        self.frame = frame
        self.clicEnCours = 0
        self.clicEnCoursX = 0
        self.clicEnCoursY = 0
        #Variables utilisees pour le carre quand on drag
        self.selectionDebut = None
        self.selectinFin = None
        self.selectionEnCours = None
        
        self.canvas = Canvas(self.frame, scrollregion=(0, 0, worldSize, worldSize), width=width, height=height)
        self.canvas.pack()
        self.canvas.bind("<Button-1>", self.carreSelectionDebut) #Clic gauche fait l'action selection
        #self.canvas.bind("<Button-2>",self.recentrer)
        self.canvas.bind("<ButtonRelease-1>", self.carreSelectionFin)
        self.canvas.bind("<B1-Motion>", self.carreDrag)
        self.canvas.bind("<Button-3>", self.action) #Clic droit fait l'action action
        self.canvas.bind("<Left>", self.scroll) #Les fleches scroll la vue
        self.canvas.bind("<Right>", self.scroll)
        self.canvas.bind("<Up>", self.scroll)
        self.canvas.bind("<Down>", self.scroll)
        self.canvas.bind("<Motion>", self.infoMouseOver)
        self.canvas.bind("<r>", self.cacherRessources)
        #self.canvas.bind("<b>",self.vue.retourVue)
        self.canvas.focus_set()
        self.canvas.configure(yscrollincrement='1')
        self.canvas.configure(xscrollincrement='1')
        self.worldSize = worldSize
        self.offsetX = 0 #Le offset represente le deplacement de la vue dans la map, car les donnees X et Y recus par les methodes sont toujours sur la taille du canvas et non pas de la map en tant que tel
        self.offsetY = 0
        self.offsetXMax = worldSize - width
        self.offsetYMax = worldSize - height
        self.uniteCourante = []
        self.batimentSelectionne=None
        self.affRessources = False
        self.dessinAttaque = []
        self.width = width
        self.height = height
        self.mousePosX=0
        self.mousePosY=0
        

        #NOTE : j'ai corrigé les chemins vers les images : j'ai simplement corriger les erreurs de casse (majuscule et minuscule)
        #que ça occasionnait sur Linux puisque les chemins de fichiers doivent respecter la casse
        self.BackgroundGalaxie = PhotoImage(file="images/galaxie.gif")
        self.BackgroundSysteme = PhotoImage(file="images/espace.gif")
        self.BackgroundPlanete = PhotoImage(file="images/planete.gif")
        self.soleil = PhotoImage(file="images/soleil_systeme.gif")
        
        
        
        self.listeImagesPlanetes=[]
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete1.gif"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete2.gif"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete3.gif"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete4.gif"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete5.gif"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete6.gif"))
        self.listeImagesPlanetes.append(PhotoImage(file="images/planete7.gif"))
        
        self.listeImagesEtoiles = []
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile1.gif"))
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile2.gif"))
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile3.gif"))
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile4.gif"))
        self.listeImagesEtoiles.append(PhotoImage(file="images/etoile5.gif"))


        ### Images des vaisseaux
        self.imageExplorateur = PhotoImage(file="images/vaisseaux/Explorateur.gif")
        self.imageTransporteur = PhotoImage(file="images/vaisseaux/Transporteur.gif")
        self.imageColonisateur = PhotoImage(file="images/vaisseaux/Colonisateur.gif")
        self.imageFregate = PhotoImage(file="images/vaisseaux/Fregate.gif")
        self.imageCroiseur = PhotoImage(file="images/vaisseaux/Croiseur.gif")


        
        #self.image = self.BackgroundFile # keep a reference!
    def cacherRessources(self, event):
        if self.affRessources:
            self.affRessources = False
        else:
            self.affRessources = True
        
    def scroll(self, event): #Methode qui scroll la vue et bouge la minimap
        if(event.keysym == "Right"):
            event.widget.xview_scroll(10, UNITS)
            if(self.offsetX < self.offsetXMax):
                self.offsetX += 10 #Change l'offset
                self.vue.minimap.posX += 1 #Bouge le rectangle de la minimap
        elif(event.keysym == "Left"):
            event.widget.xview_scroll(-10, UNITS)
            if(self.offsetX > 0):
                self.offsetX -= 10 #Change l'offset
                self.vue.minimap.posX -= 1 #Bouge le rectangle de la minimap
        elif(event.keysym == "Up"):
            event.widget.yview_scroll(-10, UNITS)
            if(self.offsetY > 0):
                self.offsetY -= 10 #Change l'offset
                self.vue.minimap.posY -= 1 #Bouge le rectangle de la minimap
        elif(event.keysym == "Down"):
            event.widget.yview_scroll(10, UNITS)
            if(self.offsetY < self.offsetYMax):
                self.offsetY += 10 #Change l'offset
                self.vue.minimap.posY += 1 #Bouge le rectangle de la minimap
    
    def recentrer(self,event):
        #on ajoute des valeurs pour avoir deux milieux
        milieuX = self.offsetX
        milieuY = self.offsetY
        
        clicX = event.x-400
        clicY = event.y-300
        
        if(clicX>200 and clicY<400):
            self.canvas.xview_moveto(200)
            self.canvas.yview_moveto(clicY)
            self.vue.minimap.posX = 20
            self.vue.minimap.posY = clicY/10    
        
    def carreSelectionDebut(self, event):
        self.selectionDebut = (event.x + self.offsetX, event.y + self.offsetY)
    
    def carreDrag(self, event):
        self.selectionEnCours = (event.x + self.offsetX, event.y + self.offsetY)
        
    def carreSelectionFin(self, event):
        self.selectionEnCours = None #Le drag est termine, donc on remet sa variable a None pour que le carre ne soit pas redessine
        self.selectionFin = (event.x + self.offsetX , event.y + self.offsetY)
        self.selection()
    
    def constructionUnitePlanete(self,unite):
        leBatiment=self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1])
        ####
        #Essai d'implémenter la barre de progression
        #leBatiment.construire(self.vueCourante.ID,unite.nom,0,0,0)
        ###
        self.vue.controleur.creerUnite(self.vueCourante.systemeParent.ID, self.vueCourante.ID,unite.nom,leBatiment.posX ,leBatiment.posY, 0,leBatiment.rallyX,leBatiment.rallyY,0)
    
    def constructionUniteSysteme(self,unite):
        leBatiment=self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1])
        ####
        #Essai d'implémenter la barre de progression
        #leBatiment.construire(self.vueCourante.ID,unite.nom,0,0,0)
        ###
        self.vue.controleur.creerUnite(self.vueCourante.ID, None,unite.nom,leBatiment.posX ,leBatiment.posY, 0,leBatiment.rallyX,leBatiment.rallyY,0)
    
        
    def selection(self): #Selectionne une unite sur le canvas
        infoSelection = ""

        if len(self.uniteCourante)==1:
            if self.uniteCourante[0][0]=="Caserne" or self.uniteCourante[0][0]=="Station Spatiale":
                self.vue.hud.enleverFrameConstruction()
        

        # Lorsqu'un bâtiments est sélectionné pour la construction, au clic gauche de la sourris il sera construit
        ##
        ### CONSTRUCTION
        ##
        #
        if self.vue.hud.choixConstruction != None:
            if(self.vueCourante.typeVue() == "Planete"):
                if self.vue.controleur.ressourcesDispo(self.vueCourante.systemeParent.getRessourcesJoueur(),self.vue.hud.choixConstruction.nom,"batiment"):
                    if self.vueCourante.placePourConstruire(self.mousePosX,self.mousePosY,self.vue.hud.choixConstruction.nom,10):
                        if self.vue.hud.choixConstruction.nom=="Mine":
                            self.vue.controleur.creerBatiment(self.vueCourante.systemeParent.ID, self.vueCourante.ID,self.vue.hud.choixConstruction.nom, self.vueCourante.laRessource.posX,self.vueCourante.laRessource.posY, 0)
                        else:
                            self.vue.controleur.creerBatiment(self.vueCourante.systemeParent.ID, self.vueCourante.ID,self.vue.hud.choixConstruction.nom, self.mousePosX, self.mousePosY, 0)
                        self.vue.hud.afficherMenuEntite()
                        
            elif(self.vueCourante.typeVue() == "Systeme"):
                if self.vue.controleur.ressourcesDispo(self.vueCourante.getRessourcesJoueur(),self.vue.hud.choixConstruction.nom,"batiment"):
                    if self.vueCourante.placePourConstruire(self.mousePosX,self.mousePosY,self.vue.hud.choixConstruction.nom,10):
                        self.vue.controleur.creerBatiment(self.vueCourante.ID, -1,self.vue.hud.choixConstruction.nom, self.mousePosX, self.mousePosY, 0)
                        self.vue.hud.afficherMenuEntite()
            self.vue.hud.arretPlacerConstruction()
        # 
        ##
        ### Vue Galaxie --> Vue Système
        ##
        #
        self.batimentSelectionne=None
        self.typeSelection="Unite"  ## par defaut // variables pour la véfication lors d'un déplacement ou une attaque
        
        if self.vueCourante.typeVue() == "Galaxie": #Si dans la galaxie
            for objet in self.vueCourante.listeSystemes:
                idDebut = objet.selection(self.selectionDebut[0], self.selectionDebut[1])
                idFin = objet.selection(self.selectionFin[0], self.selectionFin[1])
                
                if idDebut == idFin and idDebut != -1:
                    self.vue.vueCourante = objet
                    self.vueCourante = objet
                    self.vue.hud.afficherMenuEntite()
                    if self.vue.hud.frameMilieuLequel=="Construction":
                        #self.vue.hud.afficherFrameConstruction()
                        self.vue.hud.arretPlacerConstruction()
                        self.vue.hud.enleverFrameConstruction()
                    break
                else:
                    self.uniteCourante = []
                    self.typeSelection="Batiment"
                    self.batimentSelectionne=None
                
        # 
        ##
        ### Vue Système --> Vue Planète
        ##
        #  
        elif self.vueCourante.typeVue() == "Systeme": # si dans la galaxie
            self.uniteCourante = []
            for objet in self.vueCourante.listePlanetes:
                idDebut = objet.selection(self.selectionDebut[0], self.selectionDebut[1])
                idFin = objet.selection(self.selectionFin[0], self.selectionFin[1])
                
                if idDebut == idFin and idDebut != -1:
                    self.vue.vueCourante = objet
                    self.vueCourante = objet
                    self.vue.hud.afficherMenuEntite()
                    self.vue.hud.enleverFrameConstruction()
                    if self.vue.hud.frameMilieuLequel=="Construction":
                        #self.vue.hud.afficherFrameConstruction()
                        self.vue.hud.arretPlacerConstruction()
                    break

        # 
        ##
        ### Vue Système ( Target Unité )
        ##
        #  

            for objet in self.vueCourante.listeEntites:
                if(objet.selection(self.selectionDebut, self.selectionFin) == 1 and objet.joueur == self.vue.controleur.partie.joueur.nom and objet.typeEntite()=="Unite"):
                    self.uniteCourante.append([objet.nom, objet.id, self.vueCourante.ID]) #Change l'unite courrante en y ajoutant son nom et son id 
                    self.vue.hud.afficherFrameSelection()
                    self.vue.hud.enleverFrameConstruction()
                    
            if self.uniteCourante:
                if len(self.uniteCourante) == 1:
                    infoSelection = "Unite selectionnee: "
                elif len(self.uniteCourante) > 1:
                    infoSelection = "Unites selectionnees: "
                    
                for unite in self.uniteCourante:
                    infoSelection += unite[0]
                    infoSelection += ", "
                
                infoSelection = infoSelection[:-2]
            self.vue.hud.afficherMenuEntite()
                
        # 
        ##
        ### Vue Planète ( Target Unité )
        ##
        #  
        
        elif self.vueCourante.typeVue() == "Planete":
            self.uniteCourante = []
            
            for objet in self.vueCourante.listeEntites:
                if(objet.selection(self.selectionDebut, self.selectionFin) == 1 and objet.joueur == self.vue.controleur.partie.joueur.nom and objet.typeEntite()=="Unite"):
                    self.uniteCourante.append([objet.nom, objet.id, self.vueCourante.systemeParent.ID]) #Change l'unite courrante en y ajoutant son nom et son id 
                    self.vue.hud.afficherFrameSelection()
                    self.vue.hud.enleverFrameConstruction()
            if self.uniteCourante:
                if len(self.uniteCourante) == 1:
                    infoSelection = "Unite selectionnee: "
                elif len(self.uniteCourante) > 1:
                    infoSelection = "Unites selectionnees: "
                    
                for unite in self.uniteCourante:
                    infoSelection += unite[0]
                    infoSelection += ", "
                
                infoSelection = infoSelection[:-2]
            self.vue.hud.afficherMenuEntite()
            
        # 
        ##
        ### Vue Planète et Vue Système ( Target 1 batiment )
        ##
        #  
        if len(self.uniteCourante)==0:
            for objet in self.vueCourante.listeEntites:
                if(objet.selection(self.selectionDebut, self.selectionFin) == 1 and objet.joueur == self.vue.controleur.partie.joueur.nom and objet.typeEntite()=="Batiment"):
                    self.uniteCourante.append([objet.nom, objet.id]) #Change l'unite courrante en y ajoutant son nom et son id 
                    self.vue.hud.afficherFrameSelection()
            if self.uniteCourante:
                if len(self.uniteCourante) == 1:
                    infoSelection = "Unite selectionnee: "
                elif len(self.uniteCourante) > 1:
                    infoSelection = "Unites selectionnees: "
                    
                for unite in self.uniteCourante:
                    infoSelection += unite[0]
                    infoSelection += ", "
                
                infoSelection = infoSelection[:-2]
            self.vue.hud.afficherMenuEntite()
                
            if len(self.uniteCourante)==1:
                #if self.uniteCourante[0].typeEntite()=="Batiment":
                self.typeSelection="Batiment"       ##  variables pour la véfication lors d'un déplacement ou une attaque
                if self.uniteCourante[0][0]=="Caserne":
                    #if self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]).nom=="Caserne":
                    self.batimentSelectionne="Caserne"
                    self.vue.hud.afficherFrameConstruction()
                elif self.uniteCourante[0][0]=="Station Spatiale":
                    #if self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]).nom=="Caserne":
                    self.batimentSelectionne="Station Spatiale"
                    self.vue.hud.afficherFrameConstruction()
            else:
                self.uniteCourante = []
                self.typeSelection="Batiment"
                self.batimentSelectionne=None
                self.vue.hud.enleverFrameConstruction()
    
    def action(self, event): 
        modeAttaque = False
        
        if len(self.uniteCourante)==1:
            if self.uniteCourante[0][0]=="Caserne" or self.uniteCourante[0][0]=="Station Spatiale":
                self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]).rallyX=self.mousePosX
                self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]).rallyY=self.mousePosY

        # cancel le choix de construction en cours
        if self.vue.hud.choixConstruction != None:
            self.vue.hud.arretPlacerConstruction()

        
        if(self.uniteCourante)and self.typeSelection=="Unite":  #S'il y a des unites selectionnees
            self.clicEnCours = 10
            self.clicEnCoursX = event.x + self.offsetX
            self.clicEnCoursY = event.y + self.offsetY
            for objet in self.vueCourante.listeEntites:
                tuplePositionSouris = (event.x + self.offsetX, event.y + self.offsetY)
                
                #Vérifie si on clique sur l'une de nos unités
                if(objet.selection(tuplePositionSouris, tuplePositionSouris) == 1 
                   and objet.joueur != self.vue.controleur.partie.joueur.nom):
                    #return true si la cible est ennemie ou alliée
                    #change le status du joueur neutre pour ennemi
                    if(self.vue.controleur.verifierStatus(objet.joueur)):
                        for unite in self.uniteCourante:
                            if self.vueCourante.typeVue() == "Systeme":
                                self.vue.controleur.attaquerUnite(unite[1], objet.id,self.vueCourante.ID,0)
                                modeAttaque = True
                            elif self.vueCourante.typeVue() == "Planete":
                                self.vue.controleur.attaquerUnite(unite[1], objet.id,self.vueCourante.systemeParent.ID,self.vueCourante.ID)
                                modeAttaque = True
                                
            if not modeAttaque:
                for unite in self.uniteCourante:
                    if self.vueCourante.typeVue() == "Planete":
                        self.vue.controleur.deplacerUnite(unite[1], self.vueCourante.ID, self.vueCourante.systemeParent.ID, event.x + self.offsetX, event.y + self.offsetY, 0)
                    elif self.vueCourante.typeVue() == "Systeme":
                        for objet in self.vueCourante.listePlanetes:
                            self.selectionDebut = (event.x + self.offsetX, event.y + self.offsetY)
                            self.selectionFin = (event.x + self.offsetX, event.y + self.offsetY)
                            idDebut = objet.selection(self.selectionDebut[0], self.selectionDebut[1])
                            idFin = objet.selection(self.selectionFin[0], self.selectionFin[1])
                            if idDebut == idFin and idDebut != -1: #Action sur une planete
                                self.vue.controleur.entrerUnitePlanete(self.uniteCourante, self.vueCourante.ID, objet.ID)
                                break
                            else: #Action dans le vide
                                self.vue.controleur.deplacerUnite(unite[1], -1, self.vueCourante.ID, event.x + self.offsetX, event.y + self.offsetY, 0)
                    elif self.vueCourante.typeVue() == "Galaxie":
                        for objet in self.vueCourante.listeSystemes:
                            self.selectionDebut = (event.x + self.offsetX, event.y + self.offsetY)
                            self.selectionFin = (event.x + self.offsetX, event.y + self.offsetY)
                            idDebut = objet.selection(self.selectionDebut[0], self.selectionDebut[1])
                            idFin = objet.selection(self.selectionFin[0], self.selectionFin[1])
                            if idDebut == idFin and idDebut != -1: #Action sur un systeme
                                self.vue.controleur.changerSysteme(self.uniteCourante, objet.ID, self.uniteCourante[0][2])
                                #self.uniteCourante[0][2] = objet.ID
                                self.uniteCourante = []
                                self.typeSelection="Batiment"
                                self.batimentSelectionne=None
                                break
            
    def redraw(self): #Redessine le canvas; plus utile que de bouger les objets sur le canvas!!
        self.canvas.delete(ALL) #Efface tout ce qui etait affichÃƒÂ©
        self.vueCourante = self.vue.vueCourante

        
        if self.vueCourante.typeVue() == "Galaxie":
            self.canvas.create_image(500, 500,image=self.BackgroundGalaxie)
            for systeme in self.vueCourante.listeSystemes:
                #self.canvas.create_image(systeme.posX - systeme.dimX / 2+26, systeme.posY - systeme.dimY / 2+26, image=self.planete1)
                #self.canvas.create_oval(systeme.posX - systeme.dimX / 2, systeme.posY - systeme.dimY / 2, systeme.posX + systeme.dimX / 2, systeme.posY + systeme.dimY / 2, fill="yellow")
                self.canvas.create_image(systeme.posX - systeme.dimX / 2+26, systeme.posY - systeme.dimY / 2+26, image=self.listeImagesEtoiles[systeme.indexImageEtoile])
                self.canvas.create_text(systeme.posX, systeme.posY + systeme.dimY / 2 + 12, text=systeme.nom, fill="white")
                
        elif self.vueCourante.typeVue() == "Systeme":
            self.canvas.create_image(500, 500,image=self.BackgroundSysteme)
            self.canvas.create_image(500, 500,image=self.soleil)
            self.canvas.create_text(self.worldSize / 2 + 12, self.worldSize / 2 + 52, text=self.vueCourante.nom,fill="white")
            for planete in self.vueCourante.listePlanetes:
                
                self.canvas.create_image(planete.posX - planete.dimX / 2+26, planete.posY - planete.dimY / 2+26, image=self.listeImagesPlanetes[planete.indexImagePlanete])
                #self.canvas.create_oval(planete.posX - planete.dimX / 2, planete.posY - planete.dimY / 2, planete.posX + planete.dimX / 2, planete.posY + planete.dimY / 2, fill="blue")
                self.canvas.create_text(planete.posX, planete.posY + planete.dimY / 2 + 12, text=planete.nom, fill="white")
        else:
            self.canvas.create_image(500, 500,image=self.BackgroundPlanete)
            if self.affRessources:
                for ressource in self.vueCourante.listeRessources:
                    if ressource.type == "titane": #Parcours les ressources et les affiche
                        self.canvas.create_rectangle(ressource.posX - ressource.size / 2, ressource.posY - ressource.size / 2, ressource.posX + ressource.size / 2, ressource.posY + ressource.size / 2, fill=ressource.couleur, outline="black")
                    else:
                        self.canvas.create_rectangle(ressource.posX - ressource.size / 2, ressource.posY - ressource.size / 2, ressource.posX + ressource.size / 2, ressource.posY + ressource.size / 2, fill=ressource.couleur,outline="white")

        if self.dessinAttaque:
            for i in reversed(range(len(self.dessinAttaque))): #Parcours de la liste a partir de la fin, comme ca quand on delete des items on peut continuer d'iterer la liste sans que les elements changent d'index
                self.canvas.create_line(self.dessinAttaque[i][0][0], self.dessinAttaque[i][0][1], self.dessinAttaque[i][1][0], self.dessinAttaque[i][1][1], fill="red", width=2)
                self.dessinAttaque[i][2] = self.dessinAttaque[i][2] - 1
                    
                if self.dessinAttaque[i][2] <= 0:
                    del self.dessinAttaque[i]


#####################################  Dessine les BATIMENTS et UNITÉS + barres de vies + carrées de sélections
##################################### 
        for objet in self.vueCourante.listeEntites: #Liste d'entite
            if objet.typeEntite()=="Unite" or objet.typeEntite()=="Batiment":
                pourcentageVie = int((objet.nbrVies / objet.vies_max) * 100)      # calcule la vie restante a l'unitÃ©
                longueurBar = objet.dimX * (pourcentageVie / 100)  
                    
                #On recupere la liste de couleur sur le serveur. Lindice du joueur dans la liste de joueur est egal
                #a lindice de la couleur dans la liste de couleurs
                self.listeCouleurs = self.vue.controleur.retournerListeCouleursJoueurs()
                #on va chercher lindice du joueur en allant chercher le nom du joueur dans lunitee
                #on va ensuite chercher lindex en utilisant la methode index()
                
                self.laCouleur = self.listeCouleurs[self.vue.controleur.creerListeJoueurs().index(objet.joueur)]
                #self.laCouleur = self.listeCouleurs[self.vue.controleur.joueurs.index(objet.joueur)]
                    
                
                    
                if self.uniteCourante:
                    uniteTrouvee = False
                        
                    for unite in self.uniteCourante:
                        if objet.id == unite[1]:
                            if objet.typeEntite()=="Unite":
                                self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=None, outline="green", width=5)
                            elif objet.typeEntite()=="Batiment":
                                self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=None, outline="green", width=5)
                            uniteTrouvee = True
                            break          
##                        if not uniteTrouvee and objet.typeEntite()=="Unite":
##                            if objet.image:
##                                self.canvas.create_image(objet.posX, objet.posY,image=objet.image)
##                            else:
##                                self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=self.laCouleur)
##                elif objet.typeEntite()=="Unite":
##                    if objet.image:
##                        self.canvas.create_image(objet.posX, objet.posY,image=objet.image)
##                    else:
##                        self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=self.laCouleur) 
                     
                #Petit if-else rapide pour mettre la barre de vie en vert, jaune ou rouge selon la vie restante
                if pourcentageVie > 25 and pourcentageVie <= 50:   
                    self.canvas.create_rectangle(objet.posX - longueurBar / 2, objet.posY + objet.dimY / 2 + 2, objet.posX + longueurBar / 2, objet.posY + objet.dimY / 2 + 8, fill="yellow") # AJOUTE LA BAR DE VIE AUX UNITÃƒâ€°S
                elif pourcentageVie <= 25:
                    self.canvas.create_rectangle(objet.posX - longueurBar / 2, objet.posY + objet.dimY / 2 + 2, objet.posX + longueurBar / 2, objet.posY + objet.dimY / 2 + 8, fill="red")
                else:
                    self.canvas.create_rectangle(objet.posX - longueurBar / 2, objet.posY + objet.dimY / 2 + 2, objet.posX + longueurBar / 2, objet.posY + objet.dimY / 2 + 8, fill="green")
        
        
                if self.selectionEnCours:
                    self.canvas.create_rectangle(self.selectionDebut[0], self.selectionDebut[1], self.selectionEnCours[0], self.selectionEnCours[1], outline="green")


                
            #if objet.typeEntite()=="Batiment":
            if objet.image:
                if self.vueCourante.typeVue() == "Galaxie":
                    self.canvas.create_rectangle(objet.posX, objet.posY, objet.posX + 3, objet.posY + 3, fill=self.laCouleur)
                else:
                    self.canvas.create_image(objet.posX, objet.posY,image=objet.image)
            else:
                if self.vueCourante.typeVue() == "Galaxie":
                    self.canvas.create_rectangle(objet.posX, objet.posY, objet.posX + 3, objet.posY + 3, fill=self.laCouleur)
                else:
                    self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill=self.laCouleur)
                    #self.canvas.create_rectangle(objet.posX - objet.dimX / 2, objet.posY - objet.dimY / 2, objet.posX + objet.dimX / 2, objet.posY + objet.dimY / 2, fill="yellow")  

            self.canvas.create_oval(objet.posX - 5, objet.posY - 5, objet.posX + 5, objet.posY + 5, fill=self.laCouleur)
            

###############################################################################################################  



#####################################       
#####################################    Zone verte/rouge lors d'une construction
        if self.vue.hud.choixConstruction != None:
            if self.vueCourante.placePourConstruire(self.mousePosX,self.mousePosY,self.vue.hud.choixConstruction.nom,0)==True:
                self.canvas.create_rectangle(self.mousePosX-30, self.mousePosY-30, self.mousePosX+30, self.mousePosY+30, fill="green")
                self.canvas.create_image(self.mousePosX, self.mousePosY,image=self.vue.hud.choixConstruction.image)
            else:
                self.canvas.create_rectangle(self.mousePosX-30, self.mousePosY-30, self.mousePosX+30, self.mousePosY+30, fill="red")
                self.canvas.create_image(self.mousePosX, self.mousePosY,image=self.vue.hud.choixConstruction.image)
###############################################################################################################     



#####################################   Petit Rond lors d'un déplacement / d'une attaque
#####################################
        if self.clicEnCours:
            self.clicEnCours = self.clicEnCours - 1
            self.canvas.create_oval(self.clicEnCoursX - 1, self.clicEnCoursY - 1, self.clicEnCoursX + 1, self.clicEnCoursY + 1, outline="green", width=2)
            self.canvas.create_oval(self.clicEnCoursX - 10, self.clicEnCoursY - 10, self.clicEnCoursX + 10, self.clicEnCoursY + 10, outline="green", width=2)
###############################################################################################################

        if len(self.uniteCourante)==1:
            if self.uniteCourante[0][0]=="Caserne" and self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]) or self.uniteCourante[0][0]=="Station Spatiale" and self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]):
                rallyX=self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]).rallyX
                rallyY=self.vueCourante.trouverEntiteParId(self.uniteCourante[0][1]).rallyY
                self.canvas.create_oval(rallyX - 1, rallyY - 1, rallyX + 1, rallyY + 1, outline="green", width=2)
                self.canvas.create_oval(rallyX - 3, rallyY - 3, rallyX + 3, rallyY + 3, outline="red", width=2)
                self.canvas.create_oval(rallyX - 10, rallyY - 10, rallyX + 10, rallyY + 10, outline="black", width=2)
        
        #item = self.vue.frameDiplomatie.frameDiplomatie
        #item2 = self.canvas.create_window(0, 0, height = 200, width = 200, state = NORMAL, window = item, anchor=NW)
        #self.canvas.lift(item2) 
        
    def infoMouseOver(self, event): #Envoi les infos des objets sous le curseur au HUD
        infoRes = ""
        infoUnit = ""
        
        if self.vueCourante.typeVue() == "Planete": #or self.vueCourante.typeVue() =="Systeme":  Parcours les ressources sous lemplacement de la souris
            if self.affRessources:
                if(self.vueCourante.ressourceTerrainSelectionne(event.x + self.offsetX, event.y + self.offsetY) != None):
                    infoRes += "Ressource: "
                    infoRes += self.vueCourante.ressourceTerrainSelectionne(event.x + self.offsetX, event.y + self.offsetY)
            
            for objet in self.vueCourante.listeEntites: #Parcours les entites sous la souris
                tuplePositionSouris = (event.x + self.offsetX, event.y + self.offsetY)
                
                if(objet.selection(tuplePositionSouris, tuplePositionSouris) == 1 and objet.joueur != self.vue.controleur.partie.joueur.nom):
                    infoUnit += "Unite: "
                    infoUnit += objet.nom
                    infoUnit += " enemi " + "qui appartient a " + objet.joueur
                    break
                elif(objet.selection(tuplePositionSouris, tuplePositionSouris)):
                    infoUnit += "Unite: "
                    infoUnit += objet.nom
                    break
        self.mousePosX=event.x + self.offsetX
        self.mousePosY=event.y + self.offsetY
            #Envoi des infos au HUD
            #self.vue.hud.infoRes.config(text=infoRes)
            #self.vue.hud.infoUnit.config(text=infoUnit)
                
    
    def getAffRessources(self):
        return self.affRessources
    
class Hud():
    def __init__(self, vue, frame, width, height, worldSize):
        self.vue = vue
        self.worldSize = worldSize
        self.width = width
        self.height = height
        self.minimapSize = 100
        self.minimapRatio = int(self.worldSize / self.minimapSize) #Combien de fois plus petite est la minimap par rapport au monde
        self.frame = Frame(frame, width=width, height=height, background="black",relief=RIDGE, borderwidth=10) #Le frame noir du HUD comme tel
        self.frame.pack(side=BOTTOM)#, fill=BOTH)
        self.nbVieMax = -9000
        self.bouttonRetour = Button(self.frame, text="Retour", bg="blue", fg="white",borderwidth=3,relief=RIDGE, command=self.vue.retourVue)
        self.bouttonRetour.pack(side=LEFT, fill=Y)
        self.canvas = Canvas(self.frame, width=self.minimapSize, height=self.minimapSize,background="black", relief=RIDGE, borderwidth=0) #La minimap
        self.canvas.pack(side=LEFT)
        self.canvas.bind("<Button-1>", self.deplacerParLaMAP)
        self.canvas.bind("<B1-Motion>", self.deplacerParLaMAP)
        self.canvas.bind("<Button-3>", self.deplacerUnitesParLaMAP)
        #self.hint = Label(self.frame, text="Les fleches du clavier font scroller la vue.", fg="white", bg="black")
        #self.hint.pack()
        #self.infoRes = Label(self.frame, fg="white", bg="black") #Les champs d'infos, vides a la base
        #self.infoRes.pack()
        #self.infoUnit = Label(self.frame, fg="white", bg="black")
        #self.infoUnit.pack()
        #self.infoSelection = Label(self.frame, fg="white", bg="black")
        #self.infoSelection.pack()
        self.frameMilieuLequel=""
        #elements du menu
        self.menu = Frame(self.frame,width=200,height=140,background="blue", relief=RIDGE, borderwidth=3)
        self.menu.pack(side=RIGHT,fill=Y,expand=1)
        self.menu.propagate(0)
        
        
        self.boutonsActionUnites = Frame(self.frame,width=200,height=140,background="blue", relief=RIDGE, borderwidth=3)
        
        #self.boutonAttaque = Button(self.boutonActionUnites, text="Attaque")
        #self.boutonStop = Button(self.boutonActionUnites, text="Stop")
        #self.boutonSysteme = Button(self.boutonActionUnites, text="Sortir de la planete", command=lambda:self.vue.controleur.sortirUnitePlanete(self.vue.canvas.uniteCourante, self.vue.vueCourante.systemeParent.ID, self.vue.vueCourante.ID))
        self.dessine = False
        
        
        
        #self.boutonSysteme.pack()
        #frame milieu 
        self.frameMilieu = Frame(self.frame,width=450,height=140,background="black",borderwidth=2,relief=FLAT)
        self.frameMilieu.pack(side=LEFT,fill=BOTH)
        self.frameMilieu.propagate(0)
        #fin frame milieu


        self.choixConstruction=None
        # boutons pour changer entre le chat et la sélections des unités
        self.iconeChat = PhotoImage(file="images/iconeChat.gif")
        self.iconeSelection = PhotoImage(file="images/IconeSelection.gif")
        self.iconeConstruction = PhotoImage(file="images/iconeConstruction.gif")



## ICONES pour menus de construction
        
        ###  Images des batiments
        #
        #
        self.iconeMine = PhotoImage(file="images/mine.gif")
        self.iconeHabitation = PhotoImage(file="images/habitation.gif")
        self.iconeUsine = PhotoImage(file="images/usine.gif")

        self.iconeCentreCommunication = PhotoImage(file="images/centreCommunication.gif")
        self.iconeCentreRecherche = PhotoImage(file="images/centreRecherche.gif")
        self.iconeTour = PhotoImage(file="images/tour.gif")
        
        self.iconeStationSpatiale = PhotoImage(file="images/StationSpatiale.gif")
        # 
        #
        ###


        ###  Images des vaisseaux
        #
        #
        self.iconeExplorateur =PhotoImage(file="images/vaisseaux/IconeExplorateur.gif")
        self.iconeTransporteur =PhotoImage(file="images/vaisseaux/IconeTransporteur.gif")
        self.iconeColonisateur = PhotoImage(file="images/vaisseaux/IconeColonisateur.gif")
        self.iconeFregate =PhotoImage(file="images/vaisseaux/IconeFregate.gif")
        self.iconeCroiseur = PhotoImage(file="images/vaisseaux/IconeCroiseur.gif")
        # 
        #
        ###
##
        
        self.frameMilieuBoutons = Frame(self.frame,width=60,background="black",borderwidth=2,relief=FLAT)
        self.frameMilieuBoutons.pack(side=LEFT,fill=Y,expand=1)
        
        
        self.boutonVueChat=Button(self.frameMilieuBoutons, text="" ,image=self.iconeChat,command=self.afficherFrameChat)
        self.boutonVueChat.pack()
        createToolTip(self.boutonVueChat, "Chat")
        self.boutonVueUnites=Button(self.frameMilieuBoutons, text="",image=self.iconeSelection,command=self.afficherFrameSelection)
        self.boutonVueUnites.pack()
        createToolTip(self.boutonVueUnites, "Unité(s) sélectionné(s)")
        
        self.boutonVueConstruction = Button(self.frameMilieuBoutons, text="",image=self.iconeConstruction,command=self.afficherFrameConstruction)
        createToolTip(self.boutonVueConstruction, "Construction")
        
        
        self.vueChat = Frame(self.frameMilieu,width=450,height=130,background="grey",borderwidth=2,relief=FLAT)
        self.vueSelection = Frame(self.frameMilieu, width=450, height=130,background="grey",borderwidth=2,relief=FLAT)
        
        self.vueConstruction = Frame(self.frameMilieu, width=200, height=130,background="grey",borderwidth=2,relief=FLAT)
        self.vueCreationUnite = Frame(self.frameMilieu, width=200, height=130,background="grey",borderwidth=2,relief=FLAT)
        
        self.afficherFrameChat()
        
        self.vueCourante = self.vue.vueCourante
        
        self.etatActuelBoutonVueConstruction = self.vueCourante.constructionPossible(self.vue.controleur.partie.joueur.nom)
        
        #nécessaire si on commence avec un colonisateur car sinon lors de l'appel de 
        #gestionEtatBoutonVueConstruction les etats seront égaux et le bouton ne sera
        #jamais pack
        if self.vueCourante.constructionPossible(self.vue.controleur.partie.joueur.nom):
            self.boutonVueConstruction.pack()
            
        
    def afficherFrameCreationUnite(self):
        self.frameMilieuLequel="CreationUnite"

    def enleverFrameConstruction(self):
        self.vueConstruction.forget()
        self.arretPlacerConstruction()
    
    def afficherFrameConstruction(self):
        self.frameMilieuLequel="Construction"
        
        self.menu.destroy()
        self.menu = Frame(self.frame,width=200,height=120,background="blue", relief=RIDGE, borderwidth=3)
        self.menu.pack(side=RIGHT,fill=Y)
        self.menu.propagate(0)
        
        #self.vueSelection.forget()
        #self.vueChat.forget()
        self.vueConstruction.destroy()
        self.arretPlacerConstruction()
        
        self.vueConstruction = Frame(self.menu, width=200, height=120,background="blue",borderwidth=2,relief=FLAT)
        self.vueConstruction.pack(side=LEFT,fill=BOTH)
        self.vueConstruction.propagate(0)
        

        # Construction possible dans une Caserne
        if self.vue.canvas.batimentSelectionne=="Caserne":
            # Explorateur
            self.boutonConstruireExplorateur=Button(self.vueConstruction, bg="white",text="Explorateur",image=self.iconeExplorateur,command=lambda:self.vue.canvas.constructionUnitePlanete(self.boutonConstruireExplorateur))
            self.boutonConstruireExplorateur.grid(row=0, column=0)
            #self.boutonConstruireExplorateur.pack(side=LEFT)
            self.boutonConstruireExplorateur.image=self.iconeExplorateur
            self.boutonConstruireExplorateur.nom="Explorateur"
            createToolTip(self.boutonConstruireExplorateur, "Explorateur")
            # Transporteur
            self.boutonConstruireTransporteur=Button(self.vueConstruction, bg="white",text="Transporteur",image=self.iconeTransporteur,command=lambda:self.vue.canvas.constructionUnitePlanete(self.boutonConstruireTransporteur))
            self.boutonConstruireTransporteur.grid(row=0, column=1)
            #self.boutonConstruireTransporteur.pack(side=LEFT)
            self.boutonConstruireTransporteur.image=self.iconeTransporteur
            self.boutonConstruireTransporteur.nom="Transporteur"
            createToolTip(self.boutonConstruireTransporteur, "Transporteur")
        # Construction possible dans une Station Spatiale  
        elif self.vue.canvas.batimentSelectionne=="Station Spatiale":
            # Fregate
            self.boutonConstruireFregate=Button(self.vueConstruction, bg="white",text="Fregate",image=self.iconeFregate,command=lambda:self.vue.canvas.constructionUniteSysteme(self.boutonConstruireFregate))
            self.boutonConstruireFregate.grid(row=0, column=0)
            #self.boutonConstruireFregate.pack(side=LEFT)
            self.boutonConstruireFregate.image=self.iconeFregate
            self.boutonConstruireFregate.nom="Fregate"
            createToolTip(self.boutonConstruireFregate, "Fregate")
            # Croiseur
            self.boutonConstruireCroiseur=Button(self.vueConstruction, bg="white",text="Croiseur",image=self.iconeCroiseur,command=lambda:self.vue.canvas.constructionUniteSysteme(self.boutonConstruireCroiseur))
            self.boutonConstruireCroiseur.grid(row=0, column=1)
            #self.boutonConstruireCroiseur.pack(side=LEFT)
            self.boutonConstruireCroiseur.image=self.iconeCroiseur
            self.boutonConstruireCroiseur.nom="Croiseur"
            createToolTip(self.boutonConstruireCroiseur, "Croiseur")      
            # Colonisateur
            self.boutonConstruireColonisateur=Button(self.vueConstruction, bg="white",text="Colonisateur",image=self.iconeColonisateur,command=lambda:self.vue.canvas.constructionUniteSysteme(self.boutonConstruireColonisateur))
            self.boutonConstruireColonisateur.grid(row=0, column=2)
            #self.boutonConstruireColonisateur.pack(side=LEFT)
            self.boutonConstruireColonisateur.image=self.iconeColonisateur
            self.boutonConstruireColonisateur.nom="Colonisateur"
            createToolTip(self.boutonConstruireColonisateur, "Colonisateur")
            
        # Construction possible sur une planète
        elif self.vue.vueCourante.typeVue() == "Planete":
            # Mine
            self.boutonConstruireMine=Button(self.vueConstruction, bg="white",text="Mine", image=self.iconeMine, command=lambda:self.placerConstruction(self.boutonConstruireMine))
            self.boutonConstruireMine.grid(row=0, column=0)
            #self.boutonConstruireMine.pack(side=LEFT)
            self.boutonConstruireMine.image=self.iconeMine
            self.boutonConstruireMine.nom="Mine"
            createToolTip(self.boutonConstruireMine, "Mine")
            # Habitation
            self.boutonConstruireHabitation=Button(self.vueConstruction, bg="white",text="Habitation", image=self.iconeHabitation,command=lambda:self.placerConstruction(self.boutonConstruireHabitation))
            self.boutonConstruireHabitation.grid(row=0, column=1)
            #self.boutonConstruireHabitation.pack(side=LEFT)
            self.boutonConstruireHabitation.image=self.iconeHabitation
            self.boutonConstruireHabitation.nom="Habitation"
            createToolTip(self.boutonConstruireHabitation, "Habitation")
            # Caserne
            self.boutonConstruireCaserne=Button(self.vueConstruction, bg="white",text="Caserne", image=self.iconeUsine,command=lambda:self.placerConstruction(self.boutonConstruireCaserne))
            self.boutonConstruireCaserne.grid(row=0, column=2)
            #self.boutonConstruireCaserne.pack(side=LEFT)
            self.boutonConstruireCaserne.image=self.iconeUsine
            self.boutonConstruireCaserne.nom="Caserne"
            createToolTip(self.boutonConstruireCaserne, "Caserne")
            
            # Centre de recherche
            self.boutonConstruireCentreRecherche=Button(self.vueConstruction, bg="white",text="Centre Recherche", image=self.iconeCentreRecherche,command=lambda:self.placerConstruction(self.boutonConstruireCentreRecherche))
            self.boutonConstruireCentreRecherche.grid(row=1, column=0)
            #self.boutonConstruireCentreRecherche.pack(side=LEFT)
            self.boutonConstruireCentreRecherche.image=self.iconeCentreRecherche
            self.boutonConstruireCentreRecherche.nom="Centre de Recherche"
            createToolTip(self.boutonConstruireCentreRecherche, "Centre de Recherche")
            # centre de communication
            self.boutonConstruireCentreCommunication=Button(self.vueConstruction, bg="white",text="Centre de Communication", image=self.iconeCentreCommunication,command=lambda:self.placerConstruction(self.boutonConstruireCentreCommunication))
            self.boutonConstruireCentreCommunication.grid(row=1, column=1)
            #self.boutonConstruireCentreCommunication.pack(side=LEFT)
            self.boutonConstruireCentreCommunication.image=self.iconeCentreCommunication
            self.boutonConstruireCentreCommunication.nom="Centre de Communication"
            createToolTip(self.boutonConstruireCentreCommunication, "Centre de Communication")
            # tour de défense      simon:défense prend un s noob !
            self.boutonConstruireTour=Button(self.vueConstruction, bg="white",text="Tour de défense", image=self.iconeTour,command=lambda:self.placerConstruction(self.boutonConstruireTour))
            self.boutonConstruireTour.grid(row=1, column=2)
            #self.boutonConstruireTour.pack(side=LEFT)
            self.boutonConstruireTour.image=self.iconeTour
            self.boutonConstruireTour.nom="Tour"
            createToolTip(self.boutonConstruireTour, "Tour de Défense")
        # Construction dans un systèmes solaires
        
        elif self.vue.vueCourante.typeVue() == "Systeme":
            # base spatiale
            self.boutonConstruireBaseSpatiale=Button(self.vueConstruction, bg="white",text="Station spatiale", image=self.iconeStationSpatiale,command=lambda:self.placerConstruction(self.boutonConstruireBaseSpatiale))
            self.boutonConstruireBaseSpatiale.grid(row=0, column=0)
            #self.boutonConstruireBaseSpatiale.pack(side=LEFT)
            self.boutonConstruireBaseSpatiale.image=self.iconeStationSpatiale
            self.boutonConstruireBaseSpatiale.nom="Station Spatiale"
            createToolTip(self.boutonConstruireBaseSpatiale, "Station Spatiale")
            
            # tour de défence spatiale
            #self.boutonConstruireTourSpatiale=Button(self.vueConstruction, text="Tour de défence spatiale")
            #self.boutonConstruireTourSpatiale.pack(side=LEFT)
            #createToolTip(self.boutonConstruireMine, "Tour de Défence Spatiale")
            
        #if self.vueCourante.typeVue() == "Galaxie":
            
    def placerConstruction(self,batiment):
        if self.choixConstruction != None:
            self.arretPlacerConstruction()
        self.choixConstruction=batiment
        self.choixConstruction.configure(bg="blue")

    def arretPlacerConstruction(self):
        if self.choixConstruction!=None:
            self.choixConstruction.configure(bg="white")
        self.choixConstruction=None
    def creerUnite(self):
        self,systemeId, planeteId,typeUnite, posX, posY, posZ,rallyX, rallyY, rallyZ
        

    def afficherFrameSelection(self):
        self.frameMilieuLequel="Selection"
        self.vueChat.forget()
        #self.vueConstruction.forget()
        #self.arretPlacerConstruction()
        self.nombreSelections = 0
        
            
    def redessinerUniteSelectionne(self):
        self.nbVieMax = self.calculerNbVie();
        self.vueSelection.destroy()
        self.vueSelection = Frame(self.frameMilieu, width=450, height=120,background="black",borderwidth=2,relief=FLAT)
        listeSelection = self.vue.canvas.uniteCourante
       
        if self.vueCourante.typeVue() == "Planete":
            if len(listeSelection) == 1:
                objUnite = self.retournerObjetAvecId(listeSelection[0][1])
                if objUnite.typeEntite() == "Unite":
                    lImage = Label(self.vueSelection,image=objUnite.image,bg="black",padx=100000)
                    lImage.pack(side=LEFT,anchor=E)
                    vie = int(round(objUnite.vies_max*objUnite.nbrVies/100))
                    texteVie = "Vie : "+str(vie)
                    lVie = Label(self.vueSelection,text=texteVie,bg="black",fg="green",justify=LEFT)
                    lVie.pack(side=TOP,anchor=N,fill=X)
                    lNom = Label(self.vueSelection,text="Nom : "+objUnite.nom,bg="black",fg="green",justify=LEFT)
                    lNom.pack(side=TOP,anchor=N,fill=X)
                    lBouclier = Label(self.vueSelection,text="Bouclier : "+str(objUnite.bouclier),bg="black",fg="green",justify=LEFT)
                    lBouclier.pack(side=TOP,anchor=N,fill=X)      
                    lDegat = Label(self.vueSelection,text="Attaque : "+str(objUnite.degat),bg="black",fg="green",justify=LEFT)
                    lDegat.pack(side=TOP,anchor=N,fill=X)
                    lVitesse = Label(self.vueSelection,text="Vitesse d'attaque : "+str(objUnite.vitesse_attaque),bg="black",fg="green",justify=LEFT)
                    lVitesse.pack(side=TOP,anchor=N,fill=X)
                    
            else:
                for unite in listeSelection:
                    objUnite = self.retournerObjetAvecId(unite[1])
                    vie = objUnite.nbrVies
                    image = objUnite.image
                    if type(objUnite) != None:
                        if vie <= 25:
                            couleur = "red"
                        elif vie >25 and vie <50:
                            couleur = "yellow"
                        else:
                            couleur = "green"
                        self.bouton = Button(self.vueSelection, image=image,bg=couleur,height=60,width=60)
                        self.bouton.pack(side=LEFT, anchor=N)
                        self.bouton.unite =unite
                        self.bouton.bind("<Button-1>",self.selectionnerUneUnite)

            
        self.vueSelection.pack(side=LEFT,fill=BOTH)
        self.vueSelection.propagate(0)
        self.nombreSelections = len(self.vue.canvas.uniteCourante)
    
    def retournerObjetAvecId(self,id):
        if self.vue.canvas.vueCourante.typeVue() == "Planete" or self.vue.canvas.vueCourante.typeVue() == "Systeme" :
            for unite in self.vue.canvas.vueCourante.listeEntites:
                if unite.id == id:
                    return unite   
            
    def selectionnerUneUnite(self,e):
        unite = e.widget.unite
        nom = unite[0]
        id = unite[1]
        
        if self.vue.vueCourante.typeVue() == "Systeme":
            vueId = self.vue.vueCourante.ID
        elif self.vue.vueCourante.typeVue() == "Planete":
            vueId = self.vue.vueCourante.systemeParent.ID
        self.vue.canvas.uniteCourante = []
        self.vue.canvas.uniteCourante.append([nom, id, vueId])
        self.afficherMenuEntite()
        
    def afficherFrameChat(self):
        self.frameMilieuLequel="Chat"
        self.vueSelection.forget()
        
        self.vueChat.pack(side=LEFT,fill=BOTH,expand=1)
        
        self.textChat = Text(self.vueChat,width=50,height=5)
        self.textChat.grid(row=1, column=0,sticky=W)
        
        self.entreChat = Entry(self.vueChat, width=50)
        self.entreChat.grid(row=5, column=0,sticky=W)
        self.vue.canvas.canvas.focus_set()
        
        self.vueChat.bind_all("<Return>", lambda insertionTexte: self.vue.insererTexteChat(self.entreChat.get(), True))
     
    def rafraichirChat(self):
        self.leTexte = ""
        self.listeChat = self.vue.controleur.creeListeChat()
        self.textChat.delete(1.0, END)
        
        for texte in self.listeChat:
            self.leTexte += texte + "\n"
            
        self.textChat.insert(END, self.leTexte)
        self.textChat.see(END)
          
        self.leTexte = ""   
        
    def calculerNbVie(self):
        totalVie = 0
        if len(self.vue.canvas.uniteCourante)>0 and self.vueCourante.typeVue() == "Planete":
            for unite in self.vue.canvas.uniteCourante:
                if unite in self.vueCourante.listeEntites:
                    totalVie += (self.retournerObjetAvecId(unite[1])).nbrVies
        return totalVie
                
    
    def redraw(self): #Exactement le meme fonctionnement que l'interface, mais plus petit, car c'est pour la minimap
        self.canvas.delete(ALL)
        self.canvas.create_rectangle(self.vue.minimap.posX, self.vue.minimap.posY, (self.vue.minimap.posX + int(self.width / self.minimapRatio)), (self.vue.minimap.posY + int(self.height / self.minimapRatio)), outline="brown")
        self.vueCourante = self.vue.vueCourante
        
        if self.vue.canvas.getAffRessources():
            for ressource in self.vueCourante.listeRessources:
                # besoin d'une condition pour le pétrole depuis que le fond de la minimap est noir
                if ressource.type == "petrole":
                    self.canvas.create_rectangle((ressource.posX) / self.minimapRatio - (10 / self.minimapRatio), (ressource.posY) / self.minimapRatio - (10 / self.minimapRatio), (ressource.posX) / self.minimapRatio + (10 / self.minimapRatio), (ressource.posY) / self.minimapRatio + (10 / self.minimapRatio), outline="white" , fill=ressource.couleur)
                else:    
                    self.canvas.create_rectangle((ressource.posX) / self.minimapRatio - (10 / self.minimapRatio), (ressource.posY) / self.minimapRatio - (10 / self.minimapRatio), (ressource.posX) / self.minimapRatio + (10 / self.minimapRatio), (ressource.posY) / self.minimapRatio + (10 / self.minimapRatio), outline=ressource.couleur , fill=ressource.couleur)
        
         
        for objet in self.vueCourante.listeEntites:
            self.listeCouleurs = self.vue.controleur.retournerListeCouleursJoueurs()
            self.laCouleur = self.listeCouleurs[self.vue.controleur.creerListeJoueurs().index(objet.joueur)]
             
            if self.vue.canvas.uniteCourante:
                uniteTrouvee = False
                
                for unite in self.vue.canvas.uniteCourante:
                    if objet.id == unite[1]:
                        self.canvas.create_rectangle(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill=self.laCouleur, outline="green")
                        uniteTrouvee = True
                        break
                if not uniteTrouvee:
                    self.canvas.create_rectangle(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill=self.laCouleur)
            else:
                self.canvas.create_rectangle(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill=self.laCouleur)
                
        if self.vueCourante.typeVue() == "Galaxie":
            for objet in self.vueCourante.listeSystemes:
                self.canvas.create_oval(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill="yellow")
        if self.vueCourante.typeVue() == "Systeme":
            for objet in self.vueCourante.listePlanetes:
                self.canvas.create_oval(objet.posX / self.minimapRatio - objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio - objet.dimY / self.minimapRatio / 2, objet.posX / self.minimapRatio + objet.dimX / self.minimapRatio / 2, objet.posY / self.minimapRatio + objet.dimY / self.minimapRatio / 2, fill="blue")
        
        #On le redessine selon l'Ã©tat
        #self.afficherMenuEntite()
        #self.afficherFrameSelection()
        if self.nbVieMax == -9000:
            self.redessinerUniteSelectionne()
            
        if self.nbVieMax != self.calculerNbVie():
            self.redessinerUniteSelectionne()
            
        
        if self.frameMilieuLequel == "Selection" and self.nombreSelections != len(self.vue.canvas.uniteCourante):
            self.redessinerUniteSelectionne()
            
        self.gestionBoutonVueConstruction(self.vueCourante.constructionPossible(self.vue.controleur.partie.joueur.nom))
            
    def gestionBoutonVueConstruction(self,etat):
        if self.etatActuelBoutonVueConstruction != etat:
            if etat == True:
                self.etatActuelBoutonVueConstruction = etat
                self.boutonVueConstruction.pack()
            else:
                self.etatActuelBoutonVueConstruction = etat
                self.boutonVueConstruction.forget()
                    
    def deplacerParLaMAP(self, event):
        self.deplacementX = event.x
        self.deplacementY = event.y
        
        self.vue.canvas.canvas.xview_scroll(-10000, UNITS)   # met les positions de la vue aux premiÃƒÂ¨re pour ensuite les mettre au position du clic *10
        self.vue.canvas.canvas.yview_scroll(-10000, UNITS)

        if event.x * self.minimapRatio - int(self.vue.canvas.width / 2) > self.vue.canvas.offsetXMax:    # si c'est trop a droite
            self.deplacementX = int(self.vue.canvas.offsetXMax / self.minimapRatio) + int((self.vue.canvas.width / 2) / self.minimapRatio)
        if event.x * self.minimapRatio - int(self.vue.canvas.width / 2) < 0:    # si c'est trop a gauche
            self.deplacementX = int((self.vue.canvas.width / 2) / self.minimapRatio)
            
        self.vue.canvas.canvas.xview_scroll(self.deplacementX * self.minimapRatio - int(self.vue.canvas.width / 2), UNITS)
        self.vue.canvas.offsetX = self.deplacementX * self.minimapRatio - int(self.vue.canvas.width / 2) #Change l'offset
        self.vue.minimap.posX = self.deplacementX - int((self.vue.canvas.width / 2) / self.minimapRatio) #Bouge le rectangle de la minimap
            
        if event.y * 10 - int(self.vue.canvas.height / 2) > self.vue.canvas.offsetYMax:    # si c'est trop en bas
            self.deplacementY = int(self.vue.canvas.offsetYMax / 10) + int((self.vue.canvas.height / 2) / self.minimapRatio)
        if event.y * 10 - int(self.vue.canvas.height / 2) < 0:    # si c'est trop en haut
            self.deplacementY = int((self.vue.canvas.height / 2) / self.minimapRatio)
            
        self.vue.canvas.canvas.yview_scroll(self.deplacementY * self.minimapRatio - int(self.vue.canvas.height / 2), UNITS)
        self.vue.canvas.offsetY = self.deplacementY * self.minimapRatio - int(self.vue.canvas.height / 2) #Change l'offset
        self.vue.minimap.posY = self.deplacementY - int((self.vue.canvas.height / 2) / self.minimapRatio)#Bouge le rectangle de la minimap
    
    def deplacerUnitesParLaMAP(self, event): 
        if(self.vue.canvas.uniteCourante):  #S'il y a des unites selectionnees
            for unite in self.vue.canvas.uniteCourante:
                if self.vueCourante.typeVue() == "Systeme":
                    self.vue.controleur.deplacerUnite(unite[1], -1, self.vueCourante.ID, event.x * self.minimapRatio, event.y * self.minimapRatio, 0)
                else:
                    self.vue.controleur.deplacerUnite(unite[1], self.vueCourante.ID, self.vueCourante.systemeParent.ID, event.x * self.minimapRatio, event.y * self.minimapRatio, 0)  
   
   #affiche le menu ou on a le choix des actions    
    def afficherMenuEntite(self):
        # efface les choix de construction
        self.boutonsActionUnites.destroy()
        self.boutonsActionUnites = Frame(self.menu,width=200,height=140,background="blue", relief=RIDGE, borderwidth=3)
        
        self.boutonAttaque = Button(self.boutonsActionUnites, text="Attaque")
        self.boutonStop = Button(self.boutonsActionUnites, text="Stop")
        self.boutonSysteme = Button(self.boutonsActionUnites, text="Sortir de la planete", command=self.sortirPlanete)

        #self.vueSelection.forget()
        self.boutonsActionUnites.pack(side=LEFT,fill=BOTH)
        self.boutonsActionUnites.propagate(0)

        if(len(self.vue.canvas.uniteCourante)>0):
            self.boutonAttaque.pack(side=LEFT,expand=1)
            self.boutonStop.pack(side=LEFT,expand=1)
            afficherBoutonSysteme = 0
            for unite in self.vue.canvas.uniteCourante:
                if(self.vue.vueCourante.trouverEntiteParId(unite[1]) and self.vue.vueCourante.trouverEntiteParId(unite[1]).espacePossible == 1 and self.vue.vueCourante.typeVue() == "Planete"):
                    afficherBoutonSysteme = 1
                else:
                    afficherBoutonSysteme = 0
                    break
            if(afficherBoutonSysteme == 1):
                self.boutonSysteme.pack(side=LEFT,expand=1)
            else:
                self.boutonSysteme.forget()
            
        elif(len(self.vue.canvas.uniteCourante) == 0):
            self.boutonAttaque.forget()
            self.boutonStop.forget()
            self.boutonSysteme.forget()

    def sortirPlanete(self):
        self.vue.controleur.sortirUnitePlanete(self.vue.canvas.uniteCourante, self.vue.vueCourante.systemeParent.ID, self.vue.vueCourante.ID)
        self.vue.retourVue()

###### classe trouvé sur internet pour afficher une bulle d'information lorsqu'on met la sourris sur un élément du jeu... 
class ToolTip(object):
    def __init__(self, widget):
        self.widget = widget
        self.tipwindow = None
        self.id = None
        self.x = self.y = 0

    def showtip(self, text):
        "Display text in tooltip window"
        self.text = text
        if self.tipwindow or not self.text:
            return
        x, y, cx, cy = self.widget.bbox("insert")
        x = x + self.widget.winfo_rootx() + 27
        y = y + cy + self.widget.winfo_rooty() +27
        self.tipwindow = tw = Toplevel(self.widget)
        tw.wm_overrideredirect(1)
        tw.wm_geometry("+%d+%d" % (x, y))
        try:
            # For Mac OS
            tw.tk.call("::tk::unsupported::MacWindowStyle",
                       "style", tw._w,
                       "help", "noActivates")
        except TclError:
            pass
        label = Label(tw, text=self.text, justify=LEFT,
                      background="#ffffe0", relief=SOLID, borderwidth=1,
                      font=("tahoma", "8", "normal"))
        label.pack(ipadx=1)

    def hidetip(self):
        tw = self.tipwindow
        self.tipwindow = None
        if tw:
            tw.destroy()

def createToolTip(widget, text):
    toolTip = ToolTip(widget)
    def enter(event):
        toolTip.showtip(text)
    def leave(event):
        toolTip.hidetip()
    widget.bind('<Enter>', enter)
    widget.bind('<Leave>', leave)
    
    
class TechTreeWindow():
    def __init__(self, parent,frame):
        
        self.frame = frame
        self.parent = parent
        self.indexJoueur = self.parent.controleur.partie.getIndexJoueur(self.parent.controleur.partie.joueur.nom)

        
        #self.root = Tk()
        #self.root.title("Techtree")
        #padding ="5 10 10 5", 
        
        #self.spaceImage = PhotoImage(file = "images/techtree/space.gif")
        self.mainFrame = Frame(self.frame, padx ="5", pady = "10", background = "snow")
        
        #self.root.geometry("600x600")
        
        #Colonne 1
        
        #mainFrame.grid(column = 100, row = 0, sticky =(N, W, E, S))
        self.mainFrame.columnconfigure(0, weight=1)
        self.mainFrame.rowconfigure(0, weight = 1)
        
        self.croiseurImage = PhotoImage(file = "images/techtree/croiseur.gif")
        self.ligne = PhotoImage(file = "images/techtree/ligne.gif")
        self.fregate = PhotoImage(file = "images/techtree/fregate.gif")
        self.drone = PhotoImage(file = "images/techtree/drone.gif")
        
        #if self.parent.parent.modele.joueur.fregate == False:
        
            #croiseurButton = Button(self.mainFrame,image = self.croiseurImage, relief = RAISED, command =lambda:self.acheterUpgrade("upgrade Croiseur", "upgrade")).grid(column = 0, row = 1)
        Label(self.mainFrame,text ="Croiseur").grid(column = 0, row = 0)
        self.croiseurButton = Button(self.mainFrame,image = self.croiseurImage, relief = RAISED, command =lambda:self.acheterUpgrade("upgrade Croiseur", "upgrade"), state = DISABLED)
        self.croiseurButton.grid(column = 0, row = 1)
        #self.croiseurLabel = Label(self.mainFrame,image = self.croiseurImage)
        #self.croiseurLabel.grid(column = 0, row = 1)
        
        
        Label(self.mainFrame, image = self.ligne).grid(column = 0, row = 2)
        
        Label(self.mainFrame,text ="Frégate").grid(column = 0, row = 3)
        #self.fregateLabel = Label(self.mainFrame,image = self.fregate)
        #self.fregateLabel.grid(column = 0, row = 4) 
        self.fregateButton = Button(self.mainFrame,image = self.fregate, command =lambda:self.acheterUpgrade("upgrade Fregate", "upgrade"), relief = RAISED, state = DISABLED)
        self.fregateButton.grid(column = 0, row = 4)
        #fregateButton = Button(self.mainFrame,image = self.fregate, command =lambda:self.acheterUpgrade("upgrade Fregate", "upgrade"), relief = RAISED).grid(column = 0, row = 4)
        
        Label(self.mainFrame, image = self.ligne).grid(column = 0, row = 5)
        
        Label(self.mainFrame,text ="Vaisseau d'exploration").grid(column = 0, row = 6)
        self.droneButton = Button(self.mainFrame,image = self.drone, command =lambda:self.acheterUpgrade("upgrade Explorateur","upgrade"), relief = RAISED, bg = "green")
        self.droneButton.grid(column = 0, row = 7)
        
        
        #Colonne 2
        
        self.weapon1 = PhotoImage(file = "images/techtree/weapon1.gif")
        self.weapon2 = PhotoImage(file = "images/techtree/weapon2.gif")
        self.weapon3 = PhotoImage(file = "images/techtree/weapon3.gif")
        
        
        Label(self.mainFrame,text ="Arme niveau 3", padx = 40).grid(column = 1, row = 0)
        self.weapon3Button = Button(self.mainFrame,image = self.weapon3, command = lambda:self.acheterUpgrade("upgrade Arme3","upgrade"), relief = RAISED, state = DISABLED)
        self.weapon3Button.grid(column = 1, row = 1)
        
        Label(self.mainFrame, image = self.ligne).grid(column = 1, row = 2)
        
        Label(self.mainFrame,text ="Arme niveau 2").grid(column = 1, row = 3)
        self.weapon2Button = Button(self.mainFrame,image = self.weapon2, command = lambda:self.acheterUpgrade("upgrade Arme2","upgrade"), relief = RAISED, state = DISABLED)
        self.weapon2Button.grid(column = 1, row = 4)
        
        Label(self.mainFrame, image = self.ligne).grid(column = 1, row = 5)
        
        Label(self.mainFrame,text ="Arme niveau 1").grid(column = 1, row = 6)
        self.weapon1Button = Button(self.mainFrame,image = self.weapon1, command = lambda:self.acheterUpgrade("upgrade Arme1","upgrade"), relief = RAISED, bg = "green")
        self.weapon1Button.grid(column = 1, row = 7)
        
        
        #colonne 3
        
        self.shield1 = PhotoImage(file = "images/techtree/shield1.gif")
        self.shield2 = PhotoImage(file = "images/techtree/shield2.gif")
        self.shield3 = PhotoImage(file = "images/techtree/shield3.gif")
        
        Label(self.mainFrame,text ="Bouclier niveau 3").grid(column = 2, row = 0)
        self.shield3Button = Button(self.mainFrame,image = self.shield3, command = lambda:self.acheterUpgrade("upgrade Bouclier3","upgrade"), relief = RAISED, state = DISABLED)
        self.shield3Button.grid(column = 2, row = 1)
        
        Label(self.mainFrame, image = self.ligne).grid(column = 2, row = 2)
        
        Label(self.mainFrame,text ="Bouclier niveau 2").grid(column = 2, row = 3)
        self.shield2Button = Button(self.mainFrame,image = self.shield2, command = lambda:self.acheterUpgrade("upgrade Bouclier2","upgrade"), relief = RAISED, state = DISABLED)
        self.shield2Button.grid(column = 2, row = 4)
        
        Label(self.mainFrame, image = self.ligne).grid(column = 2, row = 5)
        
        Label(self.mainFrame,text ="Bouclier niveau 1").grid(column = 2, row = 6)
        self.shield1Button = Button(self.mainFrame,image = self.shield1, command = lambda:self.acheterUpgrade("upgrade Bouclier1","upgrade"), relief = RAISED, bg = "green")
        self.shield1Button.grid(column = 2, row = 7)
        self.estAfficher=False
        self.premiereFois = False
        
        
        
        #mainFrame.create_rectangle(100,100,100,100)
        
        
        #self.mainFrame.mainloop()
        
        #à terminer
    def acheterUpgrade(self, achat,type):
        
        if self.parent.vueCourante.typeVue() == "Planete":
            print("acheter")
            self.parent.controleur.verifierRessources(self.frame, self.parent.vueCourante.systemeParent.ID, self.parent.vueCourante.ID , achat, type)
        
    def afficher(self):
        if self.estAfficher:
            self.estAfficher=False
            self.premiereFois = True
        else:
            self.estAfficher=True
            self.premiereFois = True
    def redraw(self): 
        if self.estAfficher:
            if(self.premiereFois):
                self.premiereFois = False
                self.mainFrame.place(x=1005, y=52, anchor=NE)
                self.mainFrame.lift()
            
            if(self.parent.controleur.partie.joueur.listeUpgrades[self.indexJoueur][0]):
                self.droneButton.grid_remove()
                self.droneLabel = Label(self.mainFrame,image = self.drone, bg = "blue").grid(column = 0, row = 7)
                self.fregateButton.config(bg = "green", state = NORMAL)
                #self.fregateLabel.grid_remove()
                #self.fregateButton = Button(self.mainFrame,image = self.fregate, command =lambda:self.acheterUpgrade("upgrade Fregate", "upgrade"), relief = RAISED)
                #self.fregateButton.grid(column = 0, row = 4)
                                                          
            if(self.parent.controleur.partie.joueur.listeUpgrades[self.indexJoueur][1]):
                
                self.fregateButton.grid_remove()    
                Label(self.mainFrame,image = self.fregate, bg = "blue").grid(column = 0, row = 4)
                self.croiseurButton.config(bg = "green", state = NORMAL)
                
                                                                     
            if(self.parent.controleur.partie.joueur.listeUpgrades[self.indexJoueur][2]):
                
                self.croiseurLabel = Label(self.mainFrame,image = self.croiseurImage, bg = "blue").grid(column = 0, row = 1)
                
            if(self.parent.controleur.partie.joueur.listeUpgrades[self.indexJoueur][3]):
                
                Label(self.mainFrame,image = self.weapon1, bg = "blue").grid(column = 1, row = 7)
                self.weapon2Button.config(bg = "green", state = NORMAL)
                
                
            if(self.parent.controleur.partie.joueur.listeUpgrades[self.indexJoueur][4]):
                
                Label(self.mainFrame,image = self.weapon2, bg = "blue").grid(column = 1, row = 4)
                self.weapon3Button.config(bg = "green", state = NORMAL)
                
           
            if(self.parent.controleur.partie.joueur.listeUpgrades[self.indexJoueur][5]):
                
               Label(self.mainFrame,image = self.weapon3, bg = "blue").grid(column = 1, row = 1)   
               
            if(self.parent.controleur.partie.joueur.listeUpgrades[self.indexJoueur][6]):
               
               self.shield1Button.grid_remove()
               Label(self.mainFrame,image = self.shield1, bg = "blue").grid(column = 2, row = 7) 
               self.shield2Button.config(state = NORMAL, bg = "green")
               
            if(self.parent.controleur.partie.joueur.listeUpgrades[self.indexJoueur][7]):
               
               self.shield2Button.grid_remove()
               Label(self.mainFrame,image = self.shield2, bg = "blue").grid(column = 2, row = 4) 
               self.shield3Button.config(state = NORMAL, bg = "green")
               
            if(self.parent.controleur.partie.joueur.listeUpgrades[self.indexJoueur][8]):
                
               self.shield3Button.grid_remove()
               Label(self.mainFrame,image = self.shield3, bg = "blue").grid(column = 2, row = 1) 
            

        else:
            if(self.premiereFois):
                self.premiereFois = False
                self.mainFrame.place_forget()
